home *** CD-ROM | disk | FTP | other *** search
/ User's Choice Windows CD / User's Choice Windows CD (CMS Software)(1993).iso / windows4 / pcproj.zip / PROJWIND.CLS < prev    next >
Text File  |  1990-01-15  |  30KB  |  1,060 lines
  1. /* Maintain a Project chart in a Window. The ProjWindow is
  2.    responsible for all drawing of the project. The window 
  3.    has full scrolling and supports a keyboard interface.
  4.    If topMethod or botMethod are set, then the corresponding
  5.    method will be executed for each activity while displaying
  6.    the project.
  7.  
  8.    ProjWindow descends from class Window and inherits all of
  9.    its instance variables and methods.
  10.  
  11.    All strings are defined as resources for easy translation.
  12. */!!
  13.  
  14. inherit(Window, #ProjWindow, #(project     /* the project */
  15. fileName    /* of the project */
  16. actions     /* menu actions table */
  17. dirty       /* true if not saved */
  18. view        /* normal or zoomed */
  19. boxHeight   /* based on scrnsize */
  20. boxWidth    /* adjustable for zoom */
  21. boxHSpace   /* adjustable */
  22. activWidth  /* adjustable */
  23. hScrollPos  /* horiz scroll posn */
  24. vScrollPos  /* vert scroll posn */
  25. maxVisCol   /* max visible col */
  26. maxVisRow   /* max visible row */
  27. methTable   /* table of methods */
  28. topMethod   /* offset into table */
  29. botMethod   /* offset into table */
  30. gw          /* a GanttWindow */
  31. /* these are new for dragging */
  32. dragDC      /* for drawing */
  33. anchorPt    /* starting point */
  34. oldPt       /* end point */
  35. ), 2, nil)!!
  36.  
  37. now(ProjWindowClass)!!
  38.  
  39. /* Return the name of this class's MS-Windows window class
  40.   either for registration or new window creation. */
  41. Def wndClass(self)
  42. { ^"ProjWindow"  }!!
  43.  
  44. /* Create a new window class Struct.
  45.    Change the cursor to a cross.  */
  46. Def newWClass(self, lpCl, lpIcon | wc)
  47. { wc := newWClass(self:WindowClass, lpCl, lpIcon);
  48.   putWord(wc, Call LoadCursor(0, IDC_CROSS), 14);
  49.   ^wc;
  50. } !!
  51.  
  52. now(ProjWindow)!!
  53.  
  54. /* Respond to menu choice to run a program. 
  55.    By default, run MSDOS executive shell.*/
  56. Def run(self | dlg, progName)
  57. {
  58.   dlg := new(InputDialog, "Run","Program name:","MSDOS.EXE");
  59.   if runModal(dlg, INPUT_BOX, self) == IDOK
  60.     progName:=getText(dlg);
  61.     if not(find(progName, ".", 0))
  62.       progName := progName + ".EXE";
  63.     endif;
  64.     exec(progName);
  65.   endif;
  66. }!!
  67.  
  68. /* Handles menu choice to set colors. Global variables
  69.    CritColor and SlackColor determine the application
  70.    colors. */
  71. Def toggleColor(self)
  72. {
  73.   if CritColor <> BLACK
  74.     unCheckMenuItem(self, PW_COLOR);
  75.     CritColor := BLACK;
  76.     SlackColor := BLACK;
  77.   else
  78.     checkMenuItem(self, PW_COLOR);
  79.     CritColor := RED;
  80.     SlackColor := BLUE;
  81.   endif;
  82.   invalidate(self);
  83.   if gw invalidate(gw); endif;
  84. }!!
  85.  
  86. /* Create a new Milestone */
  87. Def newMilestone(self)
  88. {
  89.   newActivity(self, Milestone);
  90. }!!
  91.  
  92. /* Create the window using a "main" window style. */
  93. Def create(self, par, wName, rect, style)
  94. { 
  95.   ^create(self:Window, nil, wName, rect, 
  96.      WS_OVERLAPPEDWINDOW bitOr WS_VSCROLL bitOr WS_HSCROLL);
  97. }!!
  98.  
  99. /* Set up a dummy project, menus and the method table. */
  100. Def init(self)
  101. {  
  102.   setProject(self, new(Project));
  103.   setAutoCalc(project, true);  
  104.   setView(self, #normal);
  105.   setScrollBars(self);
  106.   setMenus(self);
  107.   checkMenuItem(self, PW_AUTOCALC);
  108.   checkMenuItem(self, PW_COLOR);
  109.   setMethTable(self);
  110. }!!
  111.  
  112. /* Set the project. */
  113. Def setProject(self, aProject)
  114. {
  115.   project := aProject;
  116. }!!
  117.  
  118. /* Set the resolution for the size of nodes, spacing etc.
  119.    based on the font text size.  There are two views,
  120.    normal and small.  Both are based on text font size so
  121.    that they will display adequately with any resolution. */
  122. Def setView(self, aView | hDC, ts)
  123. {
  124.   view := aView;
  125.   hDC := getContext(self);    /* so we can get text size */
  126.   ts := textSize(self, hDC);  /* x is width, y is height */
  127.   releaseContext(self, hDC);
  128.   if view == #small
  129.     boxWidth := x(ts) * 4;
  130.     boxHSpace := x(ts)/2 + 1;
  131.     boxHeight := y(ts) + 4;
  132.   else
  133.     boxWidth := asInt(x(ts)*8);
  134.     boxHSpace := x(ts) + 2;
  135.     boxHeight := y(ts) * 2;   
  136.   endif;
  137.   activWidth := boxWidth + boxHSpace;
  138.   reSize(self, 0, 0L);        /* so scrolling is adjusted */
  139. }!!
  140.  
  141. /* Set the scroll bar ranges and initial positions. */
  142. Def setScrollBars(self)
  143. { 
  144.   Call SetScrollRange(hWnd, SB_HORZ, 0, PW_MAX_COLS, 0);
  145.   Call SetScrollRange(hWnd, SB_VERT, 0, PW_MAX_ROWS, 0);
  146.   hScrollPos := vScrollPos := 0; 
  147. }!!
  148.  
  149. /* Set up the method table used for display options. 
  150.    Each of these methods should be applicable to all
  151.    activities in the project, that is, both Milestones
  152.    and Tasks. */
  153. Def setMethTable(self)
  154. {
  155.     methTable := #(#getTime, 
  156.                    #getSlack, 
  157.                    #getCost,
  158.                    #getEarlyStart,
  159.                    #getEarlyFinish,
  160.                    #getLateStart,
  161.                    #getLateFinish);
  162.   topMethod := 3;
  163. }!!
  164.  
  165. /* Set the method to display info below each box. 
  166.    The offset refers to the position in the
  167.    methTable. */
  168. Def setBotMethod(self, offset)
  169. {
  170.   botMethod := offset;
  171. }!!
  172.  
  173. /* Set the method to display info atop each box. 
  174.    The offset refers to the position in the
  175.    methTable. */
  176. Def setTopMethod(self, offset)
  177. {
  178.   topMethod := offset;
  179. }!!
  180.  
  181. /* Add an about box and load menu resources.
  182.    Set up the menu actions table. Each entry
  183.    consists of a constant ID and a message
  184.    that will be performed. */
  185. Def setMenus(self)
  186. {
  187.   addAbout(self);
  188.   loadMenu(self, "PWMenus");
  189.   setMenu(self, hMenu);
  190.  
  191.   actions := new(Dictionary, 30);
  192.  
  193.   add(actions, PW_FILE_NEW, #fileNew);
  194.   add(actions, PW_FILE_OPEN, #fileOpenAs);
  195.   add(actions, PW_FILE_SAVE, #fileSave);
  196.   add(actions, PW_FILE_SAVEAS, #fileSaveAs);
  197.   add(actions, PW_FILE_PRINT, #print);
  198.   add(actions, PW_FILE_PRINT_GRAPH, #printGraphs);
  199.   add(actions, PW_RUN, #run);
  200.   add(actions, PW_FILE_QUIT, #close);
  201.   add(actions, PW_CLIP, #clipChart);
  202.   add(actions, PW_ABOUT_ACTOR, #aboutActor);
  203.   add(actions, PW_DEL_ACTIVITY, #deleteActivity);
  204.   add(actions, PW_DEL_RESOURCE, #deleteResource);
  205.   add(actions, PW_NEW_MSTONE, #newMilestone);
  206.   add(actions, PW_NEW_TASK, #newTask);
  207.   add(actions, PW_NEW_PERT, #newPERTTask);
  208.   add(actions, PW_DISPLAY, #displaySettings);
  209.   add(actions, PW_COLOR, #toggleColor);
  210.   add(actions, PW_AUTOCALC, #autoCalc);
  211.   add(actions, PW_CALC, #recalc);
  212.   add(actions, PW_SHOWROOM, #showRoom);
  213.   add(actions, PW_ZOOM, #zoom);
  214.   add(actions, PW_VIEW_SUMMARY, #viewSummary);
  215.   add(actions, PW_VIEW_ACTIVITIES, #showActivities);
  216.   add(actions, PW_VIEW_GANTT, #gantt);
  217.   add(actions, PW_VIEW_RESOURCES, #showResources);
  218.   add(actions, PW_VIEW_RESOURCE, #editResource);
  219.  
  220.     /* keyboard accelerator commands */
  221.     
  222.   add(actions, PW_HELP, #help);
  223.   add(actions, EDIT_HOME, #home);
  224.   add(actions, PW_COMMAND_MODE, #commandMode);
  225. }!!
  226.  
  227. /* Convert window coordinates to relative display coordinates. */
  228. Def windowToDisplay(self, wPoint)
  229. {
  230.   ^point((x(wPoint) - boxHSpace) / activWidth  + hScrollPos,
  231.          (y(wPoint) - boxHeight) / (boxHeight*2) + vScrollPos);
  232. }!!
  233.  
  234. /* Convert relative display entries to window coordinates. 
  235.    Uses dot notation for speed. */
  236. Def displayToWindow(self, dPoint)
  237. {
  238.    ^point(boxHSpace + (dPoint.x - hScrollPos) * activWidth,
  239.           boxHeight + (dPoint.y - vScrollPos) * boxHeight*2);          
  240. }!!
  241.  
  242. /* The name of application, used for captions. */
  243. Def  appName(self)
  244. { 
  245.   ^loadString(PW_APPNAME);
  246. }!!
  247.  
  248. /* Check if there is a file error and display an error box. 
  249.    Return the error number, 0 for no error. */
  250. Def checkError(self, aFile | errNo)
  251. {
  252.    errNo := getError(aFile);
  253.    if errNo <> 0
  254.      beep();
  255.      errorBox(loadString(PW_FILEERR1),
  256.               loadString(PW_FILEERR2) + asString(aFile) +
  257.               loadString(PW_FILEERR3) + asString(errNo) +
  258.               loadString(50+errNo));
  259.    endif;
  260.    ^errNo;
  261. }!!
  262.  
  263. /* Returns true if the node is visible in the window.
  264.    Used to speed up redrawing. Uses dot notation for speed. */
  265. Def visible(self, aNode)
  266. { 
  267.   ^between(aNode.x, hScrollPos, maxVisCol + hScrollPos)
  268.      cand between(aNode.y, vScrollPos, maxVisRow + vScrollPos);
  269. }!!
  270.  
  271. /* Set up the cursor for use even if there is no mouse. */
  272. Def gotFocus(self, prevHwnd)
  273. { 
  274.   Call ShowCursor(1);
  275. }!!
  276.  
  277. /* Return to normal use of cursor.  */
  278. Def losingFocus(self, hWndNew)
  279. { 
  280.   Call ShowCursor(0);
  281. } !!
  282.  
  283. /* Check if the project has been saved. */
  284. Def shouldClose(self)
  285. { 
  286.   ^checkClean(self)
  287. }!!
  288.  
  289. /* Make sure the window knows that the project has changed. */
  290. Def dirty(self)
  291. {
  292.   invalidate(self);
  293.   dirty := true;
  294.   if gw
  295.     invalidate(gw);
  296.   endif;
  297. }!!
  298.  
  299. /* Returns boolean value true if the project has
  300.    not changed since last save.  If it is dirty,
  301.    the user is prompted for confirmation.  */
  302. Def checkClean(self)
  303. {
  304.   ^ not(dirty) cor 
  305.      yesNoBox(loadString(PW_WARNING),
  306.               loadString(PW_DISCARD)) == IDYES;
  307. }!!
  308.  
  309. /* Get the offset of the botMethod. */
  310. Def getBotMethod(self)
  311. {
  312.   ^botMethod;
  313. }!!
  314.  
  315. /* Get the offset of the topMethod. */
  316. Def getTopMethod(self)
  317. {
  318.   ^topMethod;
  319. }!!
  320.  
  321. /* Resize the window.  Adjust visible rows and cols. */
  322. Def reSize(self, wp, lp)
  323. { 
  324.   maxVisRow := bottom(clientRect(self)) / (boxHeight*2);
  325.   maxVisCol := right(clientRect(self)) / activWidth;
  326. }!!
  327.  
  328. /* Respond to MS-Windows messages to paint the window. 
  329.    Show the project as a network chart.
  330.    Draw each visible node in its proper position. 
  331.    Display the name and any other info required.
  332.    Then draw the lines to connect the outputs.
  333.    
  334.    The displayToWindow message converts a node's
  335.    logical display position to windows coordinates.
  336.    
  337.    This could be further speeded up by repainting 
  338.    only the invalid rectangle.
  339. */
  340. Def paint(self, hDC |wPoint, x, y)
  341. {
  342.   do(nodes(project), 
  343.    {using(aNode)
  344.    
  345.    wPoint := displayToWindow(self, pos(aNode));
  346.    x := x(wPoint);    /* horiz windows posn */
  347.    y := y(wPoint);    /* vert windows posn */
  348.     
  349.    if visible(self, aNode)
  350.      draw(aNode, self, x, y, hDC);  /* node knows how to draw */ 
  351.      drawTextInfo(self, aNode, x, y, hDC);
  352.    endIf;
  353.    /* always draw connections since they may be visible */
  354.    drawConnections(self, aNode, x, y, getOutputs(aNode), hDC);
  355.   }); 
  356. }!!
  357.  
  358. /* Draw lines connecting the nodes in the window. 
  359.    Uses early binding, dot notation and direct
  360.    Windows calls for speed. */
  361. Def drawConnections(self, aNode, x, y, connectedNodes, hDC | wPoint)
  362. {
  363.      do(connectedNodes,
  364.        {using(output)  
  365.         Call MoveTo(hDC,  x + boxWidth, y + boxHeight/2);
  366.         wPoint := displayToWindow(self:ProjWindow, pos(output));
  367.         Call LineTo(hDC, wPoint.x, wPoint.y + boxHeight/2);
  368.  
  369.         if critical(aNode:Activity) cand critical(output:Activity)  
  370.           Call MoveTo(hDC,  x + boxWidth, y + boxHeight/2+1);
  371.           Call LineTo(hDC, wPoint.x, wPoint.y + boxHeight/2+1);
  372.         endif;       
  373.      });   
  374. }!!
  375.  
  376. /* Draw text info in the window.  If the small view is
  377.    being used, show less information.
  378.    Uses early binding and dot notation for speed. */
  379. Def drawTextInfo(self, aNode, x, y, hDC | ts, str, strSize, offsetY, offsetX)
  380. {
  381.  ts := textSize(self, hDC);
  382.  offsetY := (boxHeight - ts.y) / 2;
  383.  strSize := boxWidth / ts.x;
  384.  if view == #small
  385.    offsetX := 2;   /* to make milestones look ok */
  386.  else
  387.    offsetX := 0;
  388.  endif;
  389.  
  390.  str := subString(aNode.name, 0, strSize-1);
  391.  Call SetTextColor(hDC, SlackColor);
  392.  Call TextOut(hDC, x + offsetX + 2, y + offsetY, str, size(str));     
  393.  
  394.  if critical(aNode)
  395.    Call SetTextColor(hDC, CritColor);
  396.  endif;
  397.  
  398.  if topMethod     /* display above box */
  399.    str := subString(asString(perform(aNode, methTable[topMethod])),0,strSize);
  400.    Call TextOut(hDC, x + 2, y - ts.y, str, size(str));
  401.  endif;
  402.  
  403.  if view ~= #small
  404.  cand botMethod     /* display below box */
  405.      str :=  subString(asString(perform(aNode, methTable[botMethod])),0,strSize);
  406.      Call TextOut(hDC, x + 2, y + boxHeight, str, size(str));
  407.  endif;
  408. }!!
  409.  
  410. /* Draw a task in the window. 
  411.    Uses early binding and direct Windows call for speed. */
  412. Def drawTask(self, aNode, x, y, hDC)
  413. {
  414.   Call Rectangle(hDC, x, y, x + boxWidth, y + boxHeight); 
  415.   if critical(aNode:Activity)
  416.     Call Rectangle(hDC, x+1, y+1, x + boxWidth-1, y + boxHeight-1);
  417.   endif;
  418. }!!
  419.  
  420. /* Draw a milestone in the window. 
  421.    Uses early binding and direct Windows call for speed. */
  422. Def drawMilestone(self, aNode, x, y, hDC)
  423. {
  424.   Call RoundRect(hDC, x, y, x + boxWidth, y + boxHeight, 20,20);
  425.   if critical(aNode:Activity)
  426.     Call RoundRect(hDC, x+1, y+1, x + boxWidth-1, y + boxHeight-1, 17,17);
  427.   endif;     
  428. }!!
  429.  
  430. /* Handle menu events, accelerator keys.
  431.    Lookup the ID in the actions table, if found
  432.    perform it.  */
  433. Def command(self, wp, lp)
  434. {
  435.   if actions[wp]
  436.     perform(self, actions[wp]);
  437.   else  /* these keys might be accelerators */
  438.     if wp == VK_UP  cor wp == VK_DOWN cor
  439.        wp == VK_RIGHT cor wp == VK_LEFT
  440.       WM_KEYDOWN(self, wp, lp);
  441.     else
  442.       beep();  /* internal error! */
  443.       errorBox(loadString(PW_ERROR1),
  444.         loadString(PW_ERROR2) + asString(wp));
  445.     endif;
  446.   endif;
  447. }!!
  448.  
  449. /* Go into "command mode" in response to a slash key accelerator.
  450.    This simulates Lotus 1-2-3 style commands by sending an
  451.    ALT key sysCommand message. */
  452. Def commandMode(self)
  453. { 
  454.   WM_SYSCOMMAND(self, 0xF100, 0L);
  455. }!!
  456.  
  457. /* Get a filename from the user in responds to menu event.
  458.    If the file has changed, check with the user.
  459.    Send a fileOpen message to do the work. */
  460. /* Respond to menu choice to create a new project. */
  461. Def fileNew(self)
  462. {
  463.   if checkClean(self)
  464.     if gw
  465.       close(gw);
  466.     endif;
  467.     fileName := nil;
  468.     dirty := nil;  
  469.     setProject(self, new(Project));
  470.     checkMenuItem(self, PW_AUTOCALC);
  471.     setAutoCalc(project, true);
  472.     setText(self, appName(self));   
  473.     editInfo(project);
  474.     invalidate(self);
  475.   endif;
  476. }!!
  477.  
  478. /* Prompt the user for the filename to open. */
  479. Def fileOpenAs(self | dlg, file, reader)
  480. {
  481.   if checkClean(self)
  482.     dlg := new(FileDialog, "*."+loadString(PW_EXTENSION));
  483.     if runModal(dlg, FILE_BOX, self) == IDOK
  484.       fileName := getFile(dlg);    
  485.       fileOpen(self, fileName);
  486.     endif;
  487.   endif;
  488. }!!
  489.  
  490. /* Open the file named fName and read a project from disk.
  491.    If a DOS error occurs (like file not found) then stop.
  492.    Uses the Language Extensions I object storage facility. 
  493.    This method copies the file into a stream so that it
  494.    can read faster.  Also, the old project, file and stream
  495.    are set to nil as soon as possible to free up memory. */
  496. Def fileOpen(self, fName | dlg, file, strm, reader)
  497. {
  498.   showWaitCurs();                       /* this takes a while */
  499.   if gw
  500.     close(gw);                          /* close old GanttWindow */
  501.   endif;      
  502.    
  503.   file := new(File);                    /* open the file etc. */
  504.   setName(file, fName);
  505.   open(file, 0);
  506.   if checkError(self, file) == 0        /* no DOS errors */
  507.     project := nil;                     /* free up memory */        
  508.   
  509.     strm := streamOver(copyFrom(file, 0, length(file))); 
  510.     close(file);
  511.     setText(self, appName(self)+": " + fName);  
  512.  
  513.     reader := new(StoredObjectReader);    
  514.     project := readFrom(reader, strm);  /* read the project */
  515.     strm := nil;                        /* free up memory */
  516.     
  517.     setAutoCalc(project, true);         /* other settings */
  518.     checkMenuItem(self, PW_AUTOCALC);
  519.     dirty := nil;
  520.     invalidate(self);                   /* redraw the window */
  521.   else
  522.     fileName := nil;                    /* due to DOS error */
  523.   endif;
  524.   showOldCurs();                        /* all done */
  525. }!!
  526.  
  527. /* Respond to menu choice to save the file.  If the file
  528.    isn't yet named, prompt the user for a name. */
  529. Def fileSave(self)
  530. {
  531.   if fileName
  532.     fileSaveIt(self, fileName);
  533.   else
  534.     fileSaveAs(self);
  535.   endif;
  536. }!!
  537.  
  538. /* Save the project to disk with a new name. */
  539. Def fileSaveAs(self | dlg)
  540. {
  541.   if not(fileName)
  542.      fileName := getName(project)+"."+loadString(PW_EXTENSION);
  543.   endif;
  544.      
  545.   dlg := new(InputDialog, loadString(PW_APPNAME),
  546.              loadString(PW_SAVEPROJ), fileName);
  547.   if runModal(dlg, INPUT_BOX, self) == IDOK         
  548.      fileName := getText(dlg);
  549.      fileSaveIt(self, fileName);
  550.   endif;
  551. }!!
  552.  
  553. /* Save the project to disk with the filename fName. 
  554.    If a DOS error occurs (like file not found) stop. 
  555.    Uses the Language Extensions I object storage facility. 
  556.    Note: this will not save any global variables!  */
  557. Def fileSaveIt(self, fName | file)
  558. {
  559.   showWaitCurs();                          /* this takes a while */
  560.   file := new(File);                       
  561.   setName(file, fName);
  562.   create(file);
  563.   if checkError(self, file) == 0           /* no DOS error */
  564.      setText(self, appName(self) + ": " + fileName);
  565.     storeOn(project, file, nil);           /* write to file */
  566.     close(file);
  567.     dirty := false;
  568.   else
  569.     fileName := nil;                       /* due to DOS error */
  570.   endif;
  571.   showOldCurs();
  572. }!!
  573.  
  574. /* Print a text summary of the project.
  575.    Uses the Printer class.  */
  576. Def print(self | prn)
  577. {
  578.   prn := new(Printer);
  579.   showWaitCurs();                              /* takes a while */
  580.   if start(prn, "Project", self)               /* start printing */
  581.      do(getInfoLines(project),
  582.        {using(line)
  583.         printLine(prn, line);
  584.      });
  585.      printLine(prn, " ");
  586.      printLine(prn, " ");
  587.      printLine(prn, loadString(PW_ACTIVT1)+":");
  588.      printLine(prn, loadString(PW_ACTIVT2));
  589.      printLine(prn, loadString(PW_ACTIVT3));
  590.      printLine(prn, "--------------------------------------------");
  591.      do(sortedActivities(project),
  592.        {using(aNode)
  593.         printLine(prn, getInfoLine(aNode));
  594.      });
  595.      
  596.      if size(resources(project)) > 0
  597.        printLine(prn, " ");
  598.        printLine(prn, " ");
  599.        printLine(prn, loadString(PW_REST1) + ":");
  600.        printLine(prn, loadString(PW_REST2));
  601.        printLine(prn, loadString(PW_REST3));
  602.        printLine(prn, "------------------------------------------");
  603.        do(resources(project),
  604.          {using(aRes)
  605.           printLine(prn, getInfoLine(aRes));
  606.        });
  607.      endif;
  608.      finish(prn);                             /* all done */
  609.      showOldCurs();
  610.   else
  611.     showOldCurs();
  612.     beep();
  613.     errorBox(loadString(PW_PRINTERR1),loadString(PW_PRINTERR2));
  614.   endif;
  615. }!!
  616.  
  617. /* Print graphics charts */
  618. Def printGraphs(self)
  619. {
  620.   printWindow(self, 1);
  621. }!!
  622.  
  623. /* Copy bitmap to clipboard */
  624. Def clipChart(self)
  625. {
  626.   clipWindow(self, 1);
  627. }
  628.  
  629. /* Create a new Milestone */
  630. Def newMilestone(self)
  631. {
  632.   newActivity(self, Milestone);
  633. }!!
  634.  
  635. /* Create a new Task */
  636. Def newTask(self)
  637. {
  638.   newActivity(self, Task);
  639. }!!
  640.  
  641. /* Create a new PERTTask */
  642. Def newPERTTask(self)
  643. {
  644.   newActivity(self, PERTTask);
  645. }!!
  646.  
  647. /* Create a new activity based on a menu choice. 
  648.    The nodeClass should be passed in as Task, Milestone etc.
  649.    Return the new activity or nil if canceled. */
  650. Def newActivity(self, nodeClass | activity)
  651. {  
  652.   activity := new(nodeClass);
  653.   setNetwork(activity, project);
  654.   if editInfo(activity) == IDOK   /* let user connect it */
  655.     if pos(activity) = 0@0        /* still not connected */
  656.       activity.y := 1;            /* safe location */
  657.       resetPosn(getNetwork(activity), activity, 0@0);
  658.     endif;
  659.     dirty(self);                  /* redraw etc. */
  660.     ^activity;
  661.   endif;
  662.   ^nil;
  663. }!!
  664.  
  665. /* Delete a resource in response to menu choice. 
  666.    Returns the deleted resource or nil if canceled. */
  667. Def deleteResource(self | dlg, name, res)
  668. { 
  669.   dlg := new(InputDialog, loadString(PW_DELRES1),
  670.       loadString(PW_DELRES2), "");
  671.   if runModal(dlg, INPUT_BOX, self) == IDOK
  672.     name := getText(dlg);
  673.     if res := checkResExists(project, name) 
  674.        delete(res, project);
  675.        dirty(self);
  676.        ^res;
  677.     endif;    
  678.   endif;
  679.   ^nil;
  680. }!!
  681.  
  682. /* Delete an activity in response to menu choice. 
  683.    Returns the deleted node or nil if canceled. */
  684. Def deleteActivity(self | dlg, name, node)
  685. { 
  686.   dlg := new(InputDialog, loadString(PW_DELACT1),
  687.       loadString(PW_DELACT2), "");
  688.   if runModal(dlg, INPUT_BOX, self) == IDOK
  689.     name := getText(dlg);
  690.     if node := checkNodeExists(project, name) 
  691.        delete(node);
  692.        dirty(self);
  693.        ^node;
  694.     endif;
  695.   endif;
  696.   ^nil
  697. }!!
  698.  
  699. /* Edit a particular resource in response to menu choice.
  700.    For now, ask the user which one. Return the resource
  701.    or nil if canceled. */
  702. Def editResource(self | dlg, res)
  703. {
  704.  dlg := new(InputDialog, loadString(PW_VIEWRES1), loadString(PW_VIEWRES2),"");
  705.  if runModal(dlg, INPUT_BOX, self) == IDOK
  706.    if res := checkResExists(project, getText(dlg))
  707.       editInfo(res);
  708.       dirty(self);
  709.       ^res;
  710.    endif;
  711.  endif;  
  712.  ^nil;
  713. }!!
  714.  
  715. /* If the user presses the home key, reset scroll posn. */
  716. Def home(self)
  717. {
  718.   hScrollPos := vScrollPos := 0;
  719.   Call SetScrollPos(hWnd, SB_HORZ, hScrollPos, 1);
  720.   Call SetScrollPos(hWnd, SB_VERT, vScrollPos, 1);
  721.   invalidate(self);
  722. }!!
  723.  
  724. /* If the right button is pressed, toggle the view
  725.    to allow zoom in and out */
  726. Def zoom(self)
  727. {
  728.    if view == #normal
  729.         setView(self, #small);
  730.    else
  731.         setView(self, #normal);
  732.    endif;
  733.    invalidate(self);
  734. }!!
  735.  
  736. /* Show the amount of memory available. */
  737. Def showRoom(self | temp)
  738. { 
  739.  temp := Call GlobalCompact(Call GlobalCompact(0)+16) / 1024;
  740.  
  741.  errorBox(loadString(PW_SHOWROOM1),
  742.    asString(temp) + loadString(PW_SHOWROOM2));
  743. }!!
  744.  
  745. /* Show all of the resources as a table. */
  746. Def showResources(self | str)
  747. {
  748.   str :=  loadString(PW_SHOWRES2) + CR_LF +
  749.          "-----------------------------------------------";
  750.   do(resources(project),
  751.     {using(res)  
  752.      str := str + CR_LF + getInfoLine(res);
  753.   });
  754.   
  755.   errorBox(loadString(PW_REST1), str);
  756. }!!
  757.  
  758. /* Respond to menu choice to recalculate. */
  759. Def recalc(self)
  760. {
  761.   showWaitCurs();
  762.   recalc(project);
  763.   invalidate(self);
  764.   if gw
  765.    invalidate(gw);
  766.   endif;
  767.   showOldCurs();
  768. }!!
  769.  
  770. /* The ganttWindow has closed.  */
  771. Def closeGantt(self)
  772. {
  773.   gw := nil;
  774.   enableMenuItem(self, PW_VIEW_GANTT);
  775. }!!
  776.  
  777. /* Respond to menu choice to set display options.  The user
  778.    can select information to be displayed above or below
  779.    the nodes in the window.  */
  780. Def displaySettings(self | dlg)
  781. {
  782.   dlg := new(PWSetDialog);
  783.   if runModal(dlg, SETTING_BOX, self) == IDOK
  784.      invalidate(self);
  785.   endif;
  786. }!!
  787.  
  788. /* Handle menu choice to create a Gantt chart. 
  789.    Create the window large enough to hold all of
  790.    the activities, plus some extra space. */
  791. Def gantt(self | height)
  792. {
  793.   if screenSize()=640@200
  794.     height := 10
  795.   else
  796.     height := 20;
  797.   endif;
  798.   gw := new(GanttWindow, self, nil, loadString(PW_GANTT),
  799.             rect(asInt(x(screenSize())/3), 
  800.               max(y(screenSize())-(size(project)+5)*height,10),
  801.               x(screenSize()), y(screenSize())));
  802.   setProject(gw, project);
  803.   show(gw,1);
  804.   grayMenuItem(self, PW_VIEW_GANTT);
  805. }!!
  806.  
  807. /* Display help information from resource file. */
  808. Def help(self | dlg)
  809. {
  810.   dlg := new(Dialog);
  811.   checkRunModal(dlg, PW_HELP_BOX, self);
  812. }!!
  813.  
  814. /* Display Actor information from resource file. */
  815. Def aboutActor(self | dlg)
  816. {
  817.   dlg := new(Dialog);
  818.   checkRunModal(dlg, PW_ABOUT_ACTOR_BOX, self);
  819. }!!
  820.  
  821. /* Handles menu choice to set autocalc. */
  822. Def autoCalc(self)
  823. {
  824.   if autoCalc(project)
  825.     unCheckMenuItem(self, PW_AUTOCALC);
  826.     setAutoCalc(project, false);
  827.   else
  828.     checkMenuItem(self, PW_AUTOCALC);
  829.     setAutoCalc(project, true);
  830.     recalc(self);
  831.   endif;
  832. }!!
  833.  
  834. /* Show all of the activities as a table. */
  835. Def showActivities(self | str)
  836. {
  837.   str := loadString(PW_SHOWACT2) + CR_LF +
  838.          "------------------------------------------";
  839.   do(sortedActivities(project),
  840.     {using(aNode)  
  841.      str := str + CR_LF + getInfoLine(aNode);
  842.   });
  843.   
  844.   errorBox(loadString(PW_ACTIVT1), str);
  845. }!!
  846.  
  847. /* Respond to menu choice to edit the project */
  848. Def viewSummary(self)
  849. {
  850.   editInfo(project);
  851. }!!
  852.  
  853. /* See if the user has double clicked on a box.
  854.    If so, bring up a dialog for editing. Return the
  855.    activity or nil if canceled. */
  856. Def WM_LBUTTONDBLCLK(self, wp, lp | dPoint, activity)
  857. {
  858.   dPoint := windowToDisplay(self, asPoint(lp));
  859.   activity := displayLookup(project, dPoint);
  860.   if activity                       /* logically true if found */
  861.     if editInfo(activity) == IDOK   /* user clicked on activity */
  862.       dirty(self);                  /* changes were made */
  863.       ^activity;
  864.     endif;
  865.   else                              /* false if nothing found */
  866.     beep();                         /* user clicked on dead space */
  867.   endif;
  868.   ^nil;
  869. }!!
  870.  
  871. /* If the right button is pressed, toggle the view
  872.    to allow zoom in and out */
  873. Def WM_RBUTTONDOWN(self, wp, lp)
  874. {
  875.   zoom(self);
  876. }!!
  877.  
  878. /* Trap keyboard events to simulate mouse. Cursor keys move
  879.    the cursor and scroll, return and F2 edit an activity.
  880.    Note anything defined as an accelerator will NOT cause
  881.    a WM_KEYDOWN message.  The keys W, X, A, D can also be 
  882.    used to move the cursor. */
  883. Def WM_KEYDOWN(self, wp, lp | pos, x, y, activity, max, dict)
  884. { 
  885.   pos := getCursorPos(self);    /* client coords */
  886.   x := x(pos);
  887.   y := y(pos);
  888.  
  889.   select
  890.     case wp == VK_UP or wp == asInt('W')
  891.       y := y - boxHeight*2;
  892.     endCase
  893.     case wp == VK_DOWN or wp == asInt('X')
  894.       y := y + boxHeight*2;
  895.     endCase
  896.     case wp == VK_LEFT or wp == asInt('A')
  897.       x := x - activWidth;
  898.     endCase
  899.     case wp == VK_RIGHT or wp == asInt('D')
  900.       x := x + activWidth;
  901.     endCase
  902.     case wp == VK_RETURN or wp == VK_F2  
  903.       WM_LBUTTONDBLCLK(self, 1, asLong(pos));
  904.     endCase    
  905.   endSelect;
  906.   
  907.  /* If the cursor is moving off screen, scroll. */
  908.   
  909.   select
  910.     case y < 0 
  911.       y := boxHeight;
  912.       WM_VSCROLL(self, SB_LINEUP, 1);
  913.     endCase
  914.     case y > max:=maxVisRow*boxHeight*2
  915.       y := max - boxHeight;
  916.       WM_VSCROLL(self, SB_LINEDOWN, 1);
  917.     endCase
  918.   endSelect;
  919.   
  920.   select
  921.     case x < 0 
  922.       x := boxHSpace;
  923.       WM_HSCROLL(self, SB_LINEUP, 1);
  924.     endCase
  925.     case x > max:=maxVisCol*activWidth
  926.       x := max - boxWidth;
  927.       WM_HSCROLL(self, SB_LINEDOWN, 1);
  928.     endCase
  929.   endSelect;
  930.  
  931.   setCursorPos(self, point(x,y));
  932. }!!
  933.  
  934. /* Trap scrolling.  Adjust as necesary.
  935.    The wp is the scroll code, the lp gives posn. */
  936. Def WM_HSCROLL(self, wp, lp | scroll)
  937. { 
  938.   select
  939.     case wp == SB_LINEUP 
  940.        scroll := -1;
  941.     endCase
  942.     case wp == SB_LINEDOWN 
  943.        scroll := 1;
  944.     endCase
  945.     case wp == SB_PAGEUP
  946.        scroll := negate(maxVisCol);
  947.     endCase;
  948.     case wp == SB_PAGEDOWN
  949.        scroll := maxVisCol;
  950.     endCase;
  951.     case wp == SB_THUMBPOSITION
  952.        hScrollPos := 0; scroll := low(lp);
  953.     endCase;
  954.     default
  955.        scroll := nil;
  956.   endSelect;
  957.  
  958.   if scroll 
  959.     hScrollPos := hScrollPos + scroll;    /* adjust */
  960.     hScrollPos := min(PW_MAX_COLS, max(0, hScrollPos));
  961.     Call SetScrollPos(hWnd, SB_HORZ, hScrollPos, 1);
  962.     invalidate(self);
  963.   endif;
  964. }!!
  965.  
  966. /* Trap scrolling.  Adjust as necesary.
  967.    The wp is the scroll code, the lp gives posn. */
  968. Def WM_VSCROLL(self, wp, lp | scroll)
  969. { 
  970.   select
  971.     case wp == SB_LINEUP 
  972.        scroll := -1;
  973.     endCase
  974.     case wp == SB_LINEDOWN 
  975.        scroll := 1;
  976.     endCase
  977.     case wp == SB_PAGEUP
  978.        scroll := negate(maxVisRow);
  979.     endCase;
  980.     case wp == SB_PAGEDOWN
  981.        scroll := maxVisRow;
  982.     endCase;
  983.     case wp == SB_THUMBPOSITION
  984.        vScrollPos := 0; scroll := low(lp);
  985.     endCase;
  986.   endSelect;
  987.  
  988.   if scroll
  989.     vScrollPos := vScrollPos + scroll;    /* adjust */
  990.     vScrollPos := min(PW_MAX_ROWS, max(0, vScrollPos));
  991.     Call SetScrollPos(hWnd, SB_VERT, vScrollPos, 1);
  992.     invalidate(self);
  993.   endif;
  994. }!!
  995.  
  996.  
  997. /* Begin dragging to allow the user to draw a line
  998.    that will connect two boxes.  Setup the anchorPt and
  999.    dragDC to allow dragging to do the drawing.
  1000.    BW 02/05/89 */
  1001. Def beginDrag(self, wp, aPt | dPoint, activity, dMode)
  1002. {
  1003.   dPoint := windowToDisplay(self, aPt);
  1004.   activity := displayLookup(project, dPoint);
  1005.   if activity   /* logically true if found */
  1006.     anchorPt := aPt;
  1007.     dragDC := getContext(self);
  1008.     dMode := Call SetROP2(dragDC,7);
  1009.     Call SelectObject(dragDC,Call GetStockObject(6));
  1010.   endif;
  1011. }!!
  1012.  
  1013. /* Do the drag and draw the feedback.
  1014.    BW 02/05/89 */
  1015. Def drag(self, wp, aPt )
  1016. { if dragDC then
  1017.     if oldPt cand (oldPt <> aPt)
  1018.       then moveTo(anchorPt,dragDC);
  1019.         lineTo(oldPt,dragDC);
  1020.     endif;
  1021.     oldPt := aPt;
  1022.     moveTo(anchorPt,dragDC);
  1023.     lineTo(aPt,dragDC);
  1024.   endif;
  1025. }!!
  1026.  
  1027. /* Finish the drag connection of two tasks.
  1028.    Create a new task if necessary. */
  1029. Def endDrag(self, wp, aPt | dPoint1, dPoint2, activity1, activity2)
  1030. {
  1031.   if dragDC then
  1032.     dPoint2 := windowToDisplay(self, aPt);
  1033.     activity2 := displayLookup(project, dPoint2);
  1034.     if activity2  /* logically true if found */
  1035.       dPoint1 := windowToDisplay(self,anchorPt);
  1036.       activity1 := displayLookup(project, dPoint1);
  1037.       if activity1 <> activity2
  1038.         connect(project,getName(activity1),
  1039.           getName(activity2));
  1040.         invalidate(self);
  1041.       endif;
  1042.     else /* maybe the user wants a new node */
  1043.       if activity2 := newActivity(self,Task) then
  1044.         dPoint1 := windowToDisplay(self,anchorPt);
  1045.         activity1 := displayLookup(project, dPoint1);
  1046.         connect(project,getName(activity1),
  1047.           getName(activity2));
  1048.         invalidate(self);
  1049.       else
  1050.         moveTo(anchorPt,dragDC); /* erase last line*/
  1051.         lineTo(oldPt,dragDC);
  1052.       endif;
  1053.     endif;
  1054.     releaseContext(self,dragDC); /* done drawing */
  1055.     dragDC := nil;
  1056.     oldPt := nil;
  1057.   endif;
  1058. }!!
  1059.  
  1060.